package com.season.seasonStudy.javase.j_001_Review;

import java.util.Iterator;

/**
 * 面向对象3大特性:
 * 	封装:
 * 		狭义：属性私有，提供公有访问器set/get，访问器中加条件(进行控制)
 *			属性名首字母小写，get属性首字母大写后面字母小写
 *		构造方法：类名和方法名相同，无返回值类型 
 *			定义：public 类名()
 *			使用：类 对象=new 类名();
 *		对象的属性：有初始化值：
 *			int			0  
 *			double		0.0  
 *			引用类型		null
 *		属性赋值方法:
 *			1.在类的定义中直接放入属性初始值
 *			2.通过定义构造方法给属性赋值
 *			3 通过对象的方法
 *		属性赋值顺序:
 *			先属性，后构造方法，最后对象的初始化方法
 *		虚拟机创建无参构造方法：前提：必须类中没有构造方法定义
 *
 *		方法重载:
 *			方法名相同，参数列表不同
 *	继承:
 *		class 父类{
 *			共同属性
 *			共同方法()
 *		}
 *		子类 extends 父类{
 *			特有属性
 *			特有的方法();
 *		}
 *
 *		使用
 *			子类 对象=new 子类();
 *		子类对象构建顺序:
 *			1.子类对象创建时，构造方法调用父类构造方法
 *			2.构建顺序:
 *				父类属性--->父类构造方法--->子类属性--->子类构造方法
 *			3.父类构造方法调用:
 *				隐式调用(自动调用父类无参构造)
 *				显式调用
 *					构造方法中调用另外一个构造方法:(放于构造方法第一句)
 *						this()调用自己的无参构造方法
 *						super()显式调用父类无参构造方法
 *		方法重写:
 *			方法定义,返回值,方法形参 相同
 *		
 *			使用子类对象.方法(实际参数)(对父类方法屏蔽)
 *			
 *		子类属性和局部变量(参数，方法内定义的变量)重名	属性被屏蔽，必须使用this获取属性
 *
 *		父类和子类属性重名：父类属性被屏蔽，必须使用super获取父类属性
 *		父类和子类相同方法定义：父类方法被屏蔽，必须使用super调用父类方法
 *
 *			super.属性
 *			super.方法()
 *			super()
 *			this()
 *			this.方法()
 *			this.属性
 *
 * 多态
 * 		1.里氏替换原则:
 * 			父类 引用 =new 子类();
 * 		2.子类重写父类方法
 * 		
 * 		3.组合方法：父类引方法（）
 * 
 * 		4.将子类对象传入父类引用
 * 
 * 接口：行为标准,规范 	
 * 		Interface 接口名{
 * 			常量;
 * 			公有抽象方法();	//这里不写方法体,里面不写东西
 * 		} 
 * 		Class 实现类 implements 接口{
 * 			实现接口的所有方法	//如果是抽象类,那就子类实现吧
 *		}
 * 
 * 
 * 关键字：
 * 		final:
 * 			终极,不能改变,
 * 			修饰:属性,方法,类,局部变量
 * 
 * 		常量：引用类型不能更换地址,但可以改变原先空间内的值(内容),值类型不能改变.
 * --------------final之后,String是不能改变值的,但是可以用StringBuffer拼接,因为没改变地址
 * 		
 * 		1常量赋值方式:
 * 			直接给,构造方法,静态代码块
 * 		方法：方法不能被重写
 * 		类：  不能派生子类
 * 
 * 
 * abstract:抽象修饰 类和方法
 * 只有方法定义,没有方法实体
 * Public abstract 返回值 方法名(参数);
 * 含有抽象方法的类必须是抽象类-------只要有抽象方法就是抽象类
 * 子类必须实现父类的抽象方法,除非是抽象类
 * 
 * 
 * static 
 * 静态,类型		这个类的所有对象共享;修饰属性,方法,类,静态代码:
 * 类名.static属性	类.static方法()
 * 
 * 静态变量使用static修饰,也叫类变量,
 * 该类所有对象共享属性, 即所有 对象改变属性值, 所有对象看到的结果一致
 * 
 * 实例变量无static修饰，每个对象独享该属性，每个对象该属性可以拥有不同的值
 * 
 * 静态方法：static修饰的方法，共享的，必须调用static变量
 * 实例方法：无static修饰的方法，对象独享，所有的变量都可使用
 * 
 * extends : 单一继承
 * 继承
 * 
 * 接口  继承  接口,接口
 * implements ：多接口实现
 * 子类 extends 父类 implements 接口1,接口2
 * 
 * this
 * super
 * 
 * 
 * 
 * 异常:
 * 		运行时发生的错误
 * 		检查时的错误是检查错误
 * 常见异常
 * 
 * 运行时异:
 * 		NullPointerException		空地址常：null
 * 		ArithmeticException			算术异常：除0等
 * 		ArrayIndexOutOfException	数组越界异常 调用下标超出数组实际长度(数组长度,在开辟空间时就确定了)
 * 		InputMismatchException		输入错误，要求数字录入字符
 * 		NumberFormatException		数字格式化异常,将字符串转化为数字时字符串不是纯数字
 * 													Integer.parse("number");
 * 		ClassCastException			类型转换异常，将父类引用转成子类对象
 * 	
 * Checked异常：编译时必须进行异常处理
 * 
 * 		ClassNotFoundException 	类型找不到异常
 * 		SQLException：			java连接数据库异常
 * 		IOException:			文件读写异常
 * 		FileNotFoundException:	文件找不异常
 * 		ParseException：			日期类型转换的异常
 * 
 * try  	内部代码可能发生异常
 * catch	使用异常处理功能
 * finally	除了虚拟机退出,最后一定会执行(return false也不能退出)
 * 				System.exit(1);
 * throws	声明方法异常，在方法定义上添加（延后处理，谁调用方法谁处理异常）
 * 				-----1.也可以自己不抛异常,自己处理,但是你不能确定会不会有意外
 * 				-----2.调用者,也就怕自己不知道会遇到的异常,自己也没可能自己去改变一切,
 * 				-----	空有抱负,自认为自己该做的,能做的更好,但是没机会,被越俎代庖了
 * throw	方法内某种条件抛出异常，程序员自己声明异常,自己定义,自己抛异常
 * 
 * 异常执行顺序:
 * 
 * 1 没有发生异常，try+finally+向下执行
 * 2 发生异常，有异常处理 try（出异常后的try接下来代码不走--->处理的catch+finally+向下运行
 * 3 发生异常，无处理     try（出异常后的try代码不走,jvm介入处理异常+finally+程序中断
 * 
 * 搭配
 * 
 * finally					必走除非调用 System.exit(1);
 * Object					所有类的父类，默认被继承
 * StringtoString()；		返回类的地址
 * boolean equals(Object o);返回是否地址相等
 * int hashCode();			返回对象的哈希码
 * 
 * 
 * 集合:
 * 		java.util包（单个值保存， 键值对保存）
 * 顶级接口 Collection接口
 * 		List接口（有序，线性，可重复）equals就可以比较内部元素了
 * 			ArrayList实现类（动态数组）随机访问效率高
 * 			LinkedList实现类（链表）添加，删除效率低	但是实现效率高
 * 
 * 		Set接口（无序，散列，唯一	  重写equals 和hashcode
 * 			HashSet实现类
 * 		
 * 		Map接口(键值存储方式，无序，键与值,分别为set,list value可重复
 * 			HashMap实现类
 * 
 * 方法使用
 * 		Collection接口
 * 			添加方法
 *			获取方法
 * 			删除方法
 * 			是否包含
 * 			长度
 * 
 * 			List接口特殊的方法
 * 				使用下标添加，删除，获取
 * 			LinkedList 特殊的方法
 * 				添加,删除,获取头部,尾部信息
 * 			Map接口的方法
 * 				添加方法
 *				获取方法
 * 				删除方法
 * 				是否包含
 * 				长度
 *	 			获取键集，值集，键值集合方法
 * 
 * 遍历集合:
 * 	1.使用长度,下标遍历
 *		for (int i = 0; i<集合.size(); i++) {
 * 			Object  o = 集合.get(i);
 * 		}
 * 	2.增强for循环	foreach	其实是把里面东西一个一个拿出来,然后赋值到那个对象,然后就可以用了
 * 		for(类型名 对象o :要遍历的集合){
 * 			o 即为集合中的对象，需要强制转换为存入类型，然后遍历
 * 		}
 * 	3.使用 Iterator迭代:
 * 		Iterator it=collection.iterator()
 * 		Iterator it=map.values().iterator();
 * 		
 * 		while (it.hasNext()) {
 * 			System.out.println(it.next());
 * 		}
 * 
 * 泛型集合(集合只能存放限定类型的对象，不需类型转换)
 * 		List<类型> list=new ArrayList<类型>();	多态的应用,如果想用LinkedList(),自己可以直接换,因为父类都一样,哦不,这里是父接口
 * 		for（类 对象 : 集合对象）{
 * 			对象，即为集合中的对象，使用该对象完成任务
 * 		}
 * 
 * Jdbc:java连接数据库技术
 * 		Odbc java----javaODBCAPI----实现--系统--辅助工具---数据
 * 		纯java驱动 java----javaAPI-----数据库驱动包（实现类---数据)
 * 
 * 		步骤:
 * 		1.jar驱动包引入项
 * 		2.使用java sql类，三个接口完成数据库连接:
 * 			Connection PreparedStatement ResultSet	
 * 			
 * 			DriverManager类：管理驱动创建数据库连接
 * 			Class.forName(“驱动类地址");
 * 			Connection conn = DriverManager.getConnection(url,usr,pwd); 
 * 				Connection接口：连接数据库,创建执行sql语句命令的对象
 * 			PreparedStatement ps= Conn.preparedStatement(sql);
 * 			Ps.set类型(第几个问号,值);	设置问号;
 * 				PreparedStatement 接口:传问号值,执行sql命令,返回结果集
 * 			1.增删改语句执行:	int row=ps.executeUpdate(); 
 * 			2.查询语句执行 		ResultSet rs=ps.executeQuery();
 * 		
 * 		3.结果处理:
 * 			ResultSet 接口：遍历结果集获取行列数
 * 			boolean rs.next():取一行,返回true说明有结果,否则没有结果
 * 			rs.get类型(列名/列数)取某行的列数据
 * 		4.关闭资源
 * 			rs.close();
 * 
 * 数据访问层：dao
 * 	实体类：entity ：数据----元素  属性-------列名   对象-------一行数据
 * 
 * 	boolean  save(实体类名 对象);	
 * 	boolean  update()	
 * 	boolean  delete(主键);	
 * 	List  findAll();
 * 		rs.next---表中的一行---对象-----list
 * 	findOne(主键);
 *  	rs.next---表中的一行---对象
 * 
 * 枚举:
 * 		枚举也是一个类
 * 		1.使用关键字enum 定义枚举类型
 * 		2.枚举值是static final的常量()可以是该类的常量对象),可变为数组,使用下标遍历,必须符合命名规范
 * 		3.可定义属性和方法，构造方法(构造方法必须私有的)
 * 	字符串转换
 * 		String 变量=枚举对象.toString();
 * 		枚举 变量=枚举.valueOf(字符串);
 * 	与int类型下标的转换:
 * 		根据下标取枚举数据
 * 			枚举类[] arr=枚举.values();
 * 			System.out.println(arr[下标]);
 * 		根据 枚举值取下标
 * 			int 下标=枚举对象.ordinal();
 * 
 * 反射:		导包：java.lang.reflect
 * Class 类：对象的类型
 * 	1.获取Class的三种方法：
 * 		1.Class cla=Class.forName(“类的地址");
 * 		2.Class cla=对象.getClass();
 * 		3.Class cla=类型.class;
 * 
 * 	2.创建类的对象
 * 		Object obj=cls.newInstance();
 * 
 * 	3.获取类中的属性
 * 		根据属性名获取对应的属性定义
 * 			Field field=cls.getDeclaredField(fieldName);
 * 		获取类中所有属性的属性数组
 * 			Field[] fields = cls.getDeclaredFields();
 * 		使用field对象
 * 			设置访问权限是否可以访问私有属性
 * 				field.setAccessible(true);
 * 		给o对象的这个属性设置value;
 * 			field.set(o, value);
 * 		获取o对象的这个属性值,存入value
 * 			Object value=field.get(o);
 * 		获取该属性的类型
 * 			Class type=field.getType()
 * 		获取该属性的修饰符
 * 			field.getModifiers()
 * 			Modifier.toString(field.getModifiers())
 * 		获取属性名
 * 			String name=field.getName();
 * 
 * 	4.获取类中的方法
 * 		根据方法�?参数类型 获取对应的方法定义（方法参数可使用可变参数或数组�?
 * 		Method meth=cls.getDeclaredMethod(methodName , Class �?可变参数类型)�?
 * 		获取类中�?��的方法定�?
 * 		Method[] meth=cls.getDeclaredMethods();
 * 		Method对象的使�?
 * 		使用方法定义调用某个对象的这个方法（参数可使用可变参数或数组�?
 * 		Object 返回�?method.invoke(方法调用的主体对�? 方法实际参数);
 * 		获取方法�?��参数类型
 * 		Class[] type=method.getParameterTypes();
 * 		获取方法的修饰符
 * 		String sign=Modifier.toString(method.getModifiers())
 * 		获取方法�?
 * 		String name=method.getName();
 * 
 * 	5.获取类中的构造方�?
 * 		获取类中�?��的构造方法定�?
 * 		Constructor[] cosArr=cls.getDeclaredConstructors()�?
 * 		根据参数类型 获取对应的构造方法定�?
 * 		Constructor constr =cls.getDeclaredConstructor(Class…可变参数类�?
 * 		Constructor对象的使�?
 * 		构�?方法创建对象
 * 		Object 对象=constr.newInstance(实参数组或可变参�?
 * 		获取构�?方法�?��参数类型
 * 		Class[] type=constr.getParameterTypes();
 * 		获取构�?方法的修饰符
 * 		String sign=Modifier.toString(constr.getModifiers());
 * 		获取构�?方法方法�?
 * 		String name=constr.getName();
 * 
 * 	6.Class获取名字
 * 		不带包名的简�?
 * 		String name=cls.getSimpleName()
 * 		带包名的名字
 * 		String name=cls.getName()
 * 
 * 
 * 
 * 文件读写�?io�
 * 文件管理 File构�?方法（地�?��
 * File对象的方法：
 * 文件流的使用�?
 * 主体�?
 * 1java程序（立足点）输入input指示从文件读入程序，output指示写入文件�?
 * 2 文件
 * Stream 流：通道
 * 字符流：处理文本文件   Reader/Writer  ----FileReader/FileWriter
 * 字节流：处理二进制文�?InputStream/OutputStream--- FileInputStream/FileOutputStream
 * 
 * 读法�?
 * 1逐个字节读，返回值是内容
 * 2 读一个数组，返回值是长度
 * 返回-1说明读完�?
 * 写法�?
 * 1逐个字节�?
 * 2 整个�?��数组的写
 * 关闭方法�?
 * 包装�?
 * BufferedReader
 * PrintWrite 
 */
public class Review {

}
